/******************************************************************************
 * @file     fast_math_functions.h
 * @brief    Public header file for NMSIS DSP Library
 * @version  V1.9.0
 * @date     23 April 2021
 * Target Processor: RISC-V Cores
 ******************************************************************************/
/*
 * Copyright (c) 2010-2020 Arm Limited or its affiliates. All rights reserved.
 * Copyright (c) 2019 Nuclei Limited. All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the License); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef _FAST_MATH_FUNCTIONS_H_
#define _FAST_MATH_FUNCTIONS_H_

#include "riscv_math_types.h"
#include "riscv_math_memory.h"

#include "dsp/none.h"
#include "dsp/utils.h"

#ifdef   __cplusplus
extern "C" {
#endif

/**
 * @brief Macros required for SINE and COSINE Fast math approximations
 */

#define FAST_MATH_TABLE_SIZE  512
#define FAST_MATH_Q31_SHIFT   (32 - 10)
#define FAST_MATH_Q15_SHIFT   (16 - 10)

#ifndef PI
#define PI               3.14159265358979f
#endif


/**
 * @defgroup groupFastMath Fast Math Functions
 * This set of functions provides a fast approximation to sine, cosine, and square root.
 * As compared to most of the other functions in the NMSIS math library, the fast math functions
 * operate on individual values and not arrays.
 * There are separate functions for Q15, Q31, and floating-point data.
 *
 */

/**
 * @ingroup groupFastMath
 */


/**
  @addtogroup sin
  @{
 */

/**
   * @brief  Fast approximation to the trigonometric sine function for floating-point data.
   * @param[in] x  input value in radians.
   * @return  sin(x).
   */
float32_t riscv_sin_f32(
    float32_t x);


/**
 * @brief  Fast approximation to the trigonometric sine function for Q31 data.
 * @param[in] x  Scaled input value in radians.
 * @return  sin(x).
 */
q31_t riscv_sin_q31(
    q31_t x);


/**
 * @brief  Fast approximation to the trigonometric sine function for Q15 data.
 * @param[in] x  Scaled input value in radians.
 * @return  sin(x).
 */
q15_t riscv_sin_q15(
    q15_t x);

/**
  @} end of sin group
 */

/**
  @addtogroup cos
  @{
 */

/**
 * @brief  Fast approximation to the trigonometric cosine function for floating-point data.
 * @param[in] x  input value in radians.
 * @return  cos(x).
 */
float32_t riscv_cos_f32(
    float32_t x);


/**
 * @brief Fast approximation to the trigonometric cosine function for Q31 data.
 * @param[in] x  Scaled input value in radians.
 * @return  cos(x).
 */
q31_t riscv_cos_q31(
    q31_t x);


/**
 * @brief  Fast approximation to the trigonometric cosine function for Q15 data.
 * @param[in] x  Scaled input value in radians.
 * @return  cos(x).
 */
q15_t riscv_cos_q15(
    q15_t x);

/**
  @} end of cos group
 */


/**
  @brief         Floating-point vector of log values.
  @param[in]     pSrc       points to the input vector
  @param[out]    pDst       points to the output vector
  @param[in]     blockSize  number of samples in each vector
  @return        none
 */
void riscv_vlog_f32(
    const float32_t* pSrc,
    float32_t* pDst,
    uint32_t blockSize);

/**
  @brief         Floating-point vector of exp values.
  @param[in]     pSrc       points to the input vector
  @param[out]    pDst       points to the output vector
  @param[in]     blockSize  number of samples in each vector
  @return        none
 */
void riscv_vexp_f32(
    const float32_t* pSrc,
    float32_t* pDst,
    uint32_t blockSize);

/**
  * @defgroup SQRT Square Root
  *
  * Computes the square root of a number.
  * There are separate functions for Q15, Q31, and floating-point data types.
  * The square root function is computed using the Newton-Raphson algorithm.
  * This is an iterative algorithm of the form:
  * <pre>
  *      x1 = x0 - f(x0)/f'(x0)
  * </pre>
  * where <code>x1</code> is the current estimate,
  * <code>x0</code> is the previous estimate, and
  * <code>f'(x0)</code> is the derivative of <code>f()</code> evaluated at <code>x0</code>.
  * For the square root function, the algorithm reduces to:
  * <pre>
  *     x0 = in/2                         [initial guess]
  *     x1 = 1/2 * ( x0 + in / x0)        [each iteration]
  * </pre>
  */


/**
 * @addtogroup SQRT
 * @{
 */

/**
  @brief         Floating-point square root function.
  @param[in]     in    input value
  @param[out]    pOut  square root of input value
  @return        execution status
                   - \ref RISCV_MATH_SUCCESS        : input value is positive
                   - \ref RISCV_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
 */
__STATIC_FORCEINLINE riscv_status riscv_sqrt_f32(
    float32_t in,
    float32_t* pOut)
{
    if (in >= 0.0f) {

#if defined ( __RISCV_FLEN )
        __ASM volatile("fsqrt.s %0, %1" : "=f"(*pOut) : "f"(in));

#else
        *pOut = sqrtf(in);
#endif

        return (RISCV_MATH_SUCCESS);
    } else {
        *pOut = 0.0f;
        return (RISCV_MATH_ARGUMENT_ERROR);
    }
}


/**
  @brief         Q31 square root function.
  @param[in]     in    input value.  The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF
  @param[out]    pOut  points to square root of input value
  @return        execution status
                   - \ref RISCV_MATH_SUCCESS        : input value is positive
                   - \ref RISCV_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
 */
riscv_status riscv_sqrt_q31(
    q31_t in,
    q31_t* pOut);


/**
  @brief         Q15 square root function.
  @param[in]     in    input value.  The range of the input value is [0 +1) or 0x0000 to 0x7FFF
  @param[out]    pOut  points to square root of input value
  @return        execution status
                   - \ref RISCV_MATH_SUCCESS        : input value is positive
                   - \ref RISCV_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
 */
riscv_status riscv_sqrt_q15(
    q15_t in,
    q15_t* pOut);

/**
 * @brief  Vector Floating-point square root function.
 * @param[in]  pIn   input vector.
 * @param[out] pOut  vector of square roots of input elements.
 * @param[in]  len   length of input vector.
 * @return The function returns RISCV_MATH_SUCCESS if input value is positive value or RISCV_MATH_ARGUMENT_ERROR if
 * <code>in</code> is negative value and returns zero output for negative values.
 */
void riscv_vsqrt_f32(
    float32_t* pIn,
    float32_t* pOut,
    uint16_t len);

void riscv_vsqrt_q31(
    q31_t* pIn,
    q31_t* pOut,
    uint16_t len);

void riscv_vsqrt_q15(
    q15_t* pIn,
    q15_t* pOut,
    uint16_t len);

/**
 * @} end of SQRT group
 */

/**
@brief         Fixed point division
@param[in]     numerator    Numerator
@param[in]     denominator  Denominator
@param[out]    quotient     Quotient value normalized between -1.0 and 1.0
@param[out]    shift        Shift left value to get the unnormalized quotient
@return        error status

When dividing by 0, an error RISCV_MATH_NANINF is returned. And the quotient is forced
to the saturated negative or positive value.
*/

riscv_status riscv_divide_q15(q15_t numerator,
                              q15_t denominator,
                              q15_t* quotient,
                              int16_t* shift);


#ifdef   __cplusplus
}
#endif

#endif /* ifndef _FAST_MATH_FUNCTIONS_H_ */
